(deftemplate actiune(multislot ora) (slot descriere))
(deftemplate intrare (slot val))
(deftemplate iesire (slot val))
(deftemplate actiuni (slot val))
(deftemplate servici (slot val))
(deftemplate ceva(slot val))


(defglobal ?*data* = (new java.util.Date))
(defglobal ?*rand* = (new java.util.Random))

(defglobal ?*succes* = false)

/*definirea orei si minutului curent si a orei si minutului de trezire*/
(defglobal ?*ora* = 2)
(defglobal ?*min* = 2)
(defglobal ?*oratrezire* = 3)
(defglobal ?*mintrezire* = 3)

/*verificarea daca este aleasa o incapere*/
(defglobal ?*alege* = false)

/*variabile ce definesc daca un electrocasnic este utilizat sau nu*/
(defglobal ?*bec* = false)
(defglobal ?*aragaz* = false)
(defglobal ?*dvdplayer* = false)
(defglobal ?*televizor* = false)
(defglobal ?*calculator* = false)
(defglobal ?*aer_conditionat* = false)

/*verifica daca este intr-o anumita incapere*/
(defglobal ?*camera* = false)
(defglobal ?*bucatarie* = false)
(defglobal ?*baie* = false)

/*verifica daca este in casa sau nu*/
(defglobal ?*afara* = false)

/*variabile definite pentru a nu putea merge la scoala sau la servici de mai multe ori*/
(defglobal ?*nservici* = 0)
(defglobal ?*nscoala* = 0)

(defglobal ?*ndus* = 0)
(defglobal ?*nmancare* = 0)
(defglobal ?*ntoaleta* = 0)
(defglobal ?*nhaine* = 0)
(defglobal ?*nbaie* = 0)
(defglobal ?*nvase* = 0)

(defglobal ?*orahaine* = 0)

/*variabila pt random*/
(defglobal ?*x* = 3)

(deffunction ia_ora ()
    (return (call ?*data* getHours )))

(deffunction ia_min ()
    (return (call ?*data* getMinutes )))

(deffunction seteaza_ora (?x)
    (call ?*data* setHours ?x))

(deffunction seteaza_min (?x)
    (call ?*data* setMinutes ?x))

(deffunction schimba_ora (?min)
    (call ?*data* setMinutes (+ ?min (ia_min)) ))

(deffunction myrandom (?i)
    (call ?*rand* nextInt ?i)
    )
/*seteaza ora de trezire*/
(deffunction sethour (?i)
    (if (eq ?i 0) 
    	then (seteaza_ora 6) (seteaza_min 0)
        else (if (eq ?i 1) 
    	then (seteaza_ora 6) (seteaza_min 30)
        else (if (eq ?i 2) 
    	then (seteaza_ora 7) (seteaza_min 0)
        else (if (eq ?i 3) 
    	then (seteaza_ora 7) (seteaza_min 30)
        else (if (eq ?i 4) 
    	then (seteaza_ora 8) (seteaza_min 0)
        else (if (eq ?i 5) 
    	then (seteaza_ora 8) (seteaza_min 30)
        else (if (eq ?i 6) 
    	then (seteaza_ora 9) (seteaza_min 0)))))))))
/*alege incaperea in care sa intre*/
(deffunction alegeintrare (?i)
    (assert (intrare (val ?i)))
)
(deffunction alegeiesire (?i)
     (assert (iesire (val ?i))))
(deffunction alegeactiune (?i)
    (assert (actiuni (val ?i))))
(deffunction alegesaplece (?i)
    (assert (servici (val ?i))))
(deffunction alegeceva (?i)
    (assert (ceva (val ?i))))

(assert (actiune (ora "noaptea") (descriere "toata lumea doarme")))
(assert (actiune (ora "noaptea ") (descriere "ora de culcare")))


(defrule alege_ora_trezire
    (declare (salience 100))
    ?id <- (actiune (ora "noaptea") (descriere "toata lumea doarme"))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 7))
    (sethour ?*x*)
    (bind ?*ora* (ia_ora))
	(bind ?*min* (ia_min))
	(bind ?*oratrezire* ?*ora*)
	(bind ?*mintrezire* ?*min*)
    (bind ?*camera* true)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se trezeste"))) 
    )
(defrule trezire
    (actiune (ora $? ?ora &?*ora* ?min &?*min*) (descriere ?desc &"se trezeste"))
    =>
    (printout t ?desc " la ora "?ora ":"?min crlf)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "aprinde becul")))
    )

/*nu merge*/
(defrule culcare
    (actiune (ora "noaptea ") (descriere "ora de culcare"))
    (test (eq (- ?*ora*  ?*oratrezire*) 16 ))
    =>
    (printout t "Totul a fost stins. E ora de somn!")
    (exit)
    )

(defrule aprinde_bec    
    (declare (salience 90))
    (actiune (ora ?*ora* ?*min*) (descriere "aprinde becul"))
    (test (eq ?*bec* false))
    =>
    (printout t "aprinde becul la ora "?*ora* ":"?*min* crlf)
    (bind ?*bec* true)
    (assert (actiune (ora "ora") (descriere "actiune")))
    )
(defrule stinge_bec     
    (declare (salience 90))
  	(actiune (ora ?*ora* ?*min) (descriere "stinge becul")) 
    (test (eq ?*bec* true))
    =>
    (bind ?*bec* false)
    (printout t "stinge becul la ora "?*ora* ":"?*min* crlf)
    )

(defrule intra
    (declare (salience 80))
    ?id<-(actiune (ora "ora") (descriere "intra undeva"))
    =>
    (bind ?*x* (myrandom 3))
    (alegeintrare ?*x*)
    (retract ?id)    
    (assert (actiune (ora ?*min* ?*ora*) (descriere "aprinde becul")))
    )
(defrule ibucatarie
    ?id<-(intrare (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "intra in bucatarie")))
    )
(defrule ibaie
    ?id<-(intrare (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "intra in baie")))
    )
(defrule icamera
    ?id<-(intrare (val 2))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "intra in camera")))
    )
(defrule intra_bucatarie
    (actiune (ora ?*ora* ?*min*) (descriere "intra in bucatarie"))
    (test (eq ?*bucatarie* false))
    (test (eq ?*baie* false))
    (test (eq ?*camera* false))
    (test (eq ?*alege* true))
    =>
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*bucatarie* true)
    (bind ?*alege* false)
    (printout t "intra in bucatarie la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    )
(defrule intra_baie
    (actiune (ora ?*ora* ?*min*) (descriere "intra in baie"))
    (test (eq ?*baie* false))
    (test (eq ?*bucatarie* false))
    (test (eq ?*camera* false))
    (test (eq ?*alege* true))
    =>
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*baie* true)
    (bind ?*alege* false)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (printout t "intra in baie la ora "?*ora* ":"?*min* crlf)    
    )
(defrule intra_camera
    (actiune (ora ?*ora* ?*min*) (descriere "intra in camera"))
    (test (eq ?*camera* false))
    (test (eq ?*baie* false))
    (test (eq ?*bucatarie* false))
    (test (eq ?*alege* true))
    =>    
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*camera* true)
    (bind ?*alege* false)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (printout t "intra in camera la ora "?*ora* ":"?*min* crlf)
    )
/*trebuie ales momentul iesirii din incapere*/
(defrule iese
    (declare (salience 80))
    (actiune (ora "ora") (descriere "alege iesire"))
    =>
    (bind ?*x* (myrandom 2))
    (alegeiesire ?*x*)
    )
(defrule iese2
    ?id<-(iesire (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "iese")))
    )
(defrule iese_bucatarie
    ?id<-(actiune (ora "ora") (descriere "iese"))
    (test (eq ?*bucatarie* true))
    (test (eq ?*baie* false))
    (test (eq ?*camera* false))
    =>
    (retract ?id)
    (bind ?*bucatarie* false)
    (bind ?*alege* true)
    (printout t "iese din bucatarie la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "iese din bucatarie")))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "stinge becul")))    
    (assert (actiune (ora "ora") (descriere "alege ceva")))
    )
(defrule iese_baie
    ?id<-(actiune (ora "ora") (descriere "iese"))
    (test (eq ?*baie* true))
    (test (eq ?*camera* false))
    (test (eq ?*bucatarie* false))
    =>
    (retract ?id)
    (bind ?*baie* false)
    (bind ?*alege* true)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "iese din baie")))
    (printout t "iese din baie la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege ceva")))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "stinge becul")))
    )
(defrule iese_camera
    ?id<-(actiune (ora "ora") (descriere "iese"))
    (test (eq ?*camera* true))
    (test (eq ?*baie* false))
    (test (eq ?*bucatarie* false))
    =>
    (retract ?id)
    (bind ?*camera* false)
    (bind ?*alege* true)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "iese din camera")))
    (printout t "iese din camera la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege ceva")))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "stinge becul")))
    )

(defrule ceva
    (declare (salience 80))
    ?id<-(actiune (ora "ora") (descriere "alege ceva"))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 2))
    (alegeceva ?*x*)
    )

(defrule ceva1
    ?id<-(ceva (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "intra undeva"))))

(defrule ceva2
    ?id<-(ceva (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "alege plecare"))))

(defrule pleaca
    (declare (salience 80))
    ?id<-(actiune (ora "ora") (descriere "alege plecare"))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 2))
    (alegesaplece ?*x*)
    )
(defrule alegeservici
    ?id<-(servici (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora")(descriere "pleaca la servici"))))
(defrule alegescoala
    ?id<-(servici (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora")(descriere "pleaca la scoala"))))
(defrule alegeafara
    ?id<-(servici (val 2))
    =>
    (retract ?id)
    (assert (actiune (ora "ora")(descriere "pleaca afara"))))
(defrule merge_servici
    ?id<-(actiune (ora "ora") (descriere "pleaca la servici"))
    (test (eq ?*afara* false))
    (test (eq ?*nservici* 0))
    (test (eq ?*nscoala* 0))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "merge la servici")))
    (printout t "merge la servici la ora "?*ora* ":"?*min* crlf)
    (bind ?*nservici* 1)
    (bind ?*nscoala* 1)
    (bind ?*afara* true)
    (schimba_ora 540)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))    
    (assert (actiune (ora ?*ora* ?*min*) (descriere "vine de la servici")))
    (printout t "vine de la servici la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "intra undeva")))
    )
(defrule merge_scoala
    ?id<-(actiune (ora "ora") (descriere "pleaca la scoala"))
    (test (eq ?*afara* false))
    (test (eq ?*nscoala* 0))
    (test (eq ?*nservici* 0))
    (test (eq ?*ora* 8))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "merge la scoala")))
    (printout t "merge la scoala la ora "?*ora* ":"?*min* crlf)
    (bind ?*nscoala* 1)
    (bind ?*nservici* 1)
    (bind ?*afara* true)
    (schimba_ora 360)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "vine de la scoala")))
    (printout t "vine de la scoala la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "intra undeva"))))
(defrule merge_afara
    ?id<-(actiune (ora "ora") (descriere "pleaca afara"))
    (test (eq ?*afara* false))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "merge afara")))
    (printout t "merge afara la ora "?*ora* ":"?*min* crlf)
    (schimba_ora 30)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "vine de afara")))
    (printout t "vine de afara la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "intra undeva"))))

(defrule alegeact
    ?id<-(iesire (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "actiune")))
    )
(defrule alege_actiune   
    (declare (salience 80)) 
    ?id<-(actiune (ora "ora") (descriere "actiune"))
    =>    
    (retract ?id)
    (bind ?*x* (myrandom 24))
    (alegeactiune ?*x*)
    )
(defrule alegetoaleta
    ?id<-(actiuni (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "toaleta")))
    )
(defrule foloseste_toaleta
    ?id<-(actiune (ora "ora") (descriere "toaleta"))
    (test (eq ?*baie* true))
    (test (neq ?*ntoaleta* 5))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste toaleta")))
    (printout t "foloseste toaleta la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)    
    (bind ?*ntoaleta* (+ 1 ?*ntoaleta*))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la chiuveta")))
    (printout t "se spala la chiuveta la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    )
(defrule alegehiuveta
    ?id<-(actiuni (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "chiuveta")))
    )
(defrule spala_chiuveta
    ?id<-(actiune (ora "ora") (descriere "chiuveta"))
    (test (eq ?*baie* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la chiuveta")))
    (printout t "se spala la chiuveta la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    )
(defrule alegedus
    ?id<-(actiuni (val 2))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "dus")))
    )
(defrule spala_dus
    ?id<-(actiune (ora "ora") (descriere "dus"))
    (test (eq ?*baie* true))
    (test (neq ?*ndus* 2))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la dus")))
    (printout t "se spala la dus la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 20)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    (bind ?*ndus* (+ 1 ?*ndus*))
    )
(defrule alegehaine
    ?id<-(actiuni (val 3))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "haine")))
    )
(defrule spala_haine
    ?id<-(actiune (ora "ora") (descriere "haine"))
    (test (eq ?*baie* true))
    (test (neq ?*nhaine* 3))
    (test (eq 1 (- ?*orahaine* ?*ora*)))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "spala haine")))
    (printout t "spala haine la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    (bind ?*orahaine* ?*ora*)
    (bind ?*nhaine* (+ 1 ?*nhaine*))
    )
(defrule alegebaie
    ?id<-(actiuni (val 4))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "curatenie")))
    )
(defrule curata_baie
   ?id<-(actiune (ora "ora") (descriere "curatenie"))
    (test (eq ?*baie* true))
    (test (eq ?*nbaie* 0))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "face curat in baie")))
    (printout t "face curat in baie la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 30)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    (bind ?*nbaie* 1)
    )
(defrule alegemicrounde
    ?id<-(actiuni (val 5))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "microunde")))
    )
(defrule porneste_cuptor_microunde
    ?id<-(actiune (ora "ora") (descriere "microunde"))
    (test (eq ?*bucatarie* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste cuptorul cu microunde")))
    (printout t "foloseste cuptorul cu microunde la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 2)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    )
(defrule alegearagaz
    ?id<-(actiuni (val 6))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "aragaz")))
    )
(defrule porneste_aragaz   
 	?id<-(actiune (ora "ora") (descriere "aragaz"))
    (test (eq ?*bucatarie* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste aragazul")))
    (printout t "foloseste aragazul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 15)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    )
(defrule alegefiltru
    ?id<-(actiuni (val 7))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "filtru")))
    )
(defrule porneste_filtru_cafea   
 	?id<-(actiune (ora "ora") (descriere "filtru"))
    (test (eq ?*bucatarie* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste filtrul de cafea")))
    (printout t "foloseste filtrul de cafea la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 10)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true))
(defrule alegevase
    ?id<-(actiuni (val 8))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "vase")))
    )
(defrule porneste_masina_spalat_vase
	 ?id<-(actiune (ora "ora") (descriere "vase"))
    (test (eq ?*bucatarie* true))
    (test (neq ?*nvase* ?*nmancare*))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "spala vasele")))
    (printout t "spala vasele la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 15)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    (bind ?*nvase* (+ 1 ?*nvase*))
    )
(defrule alegepaine
    ?id<-(actiuni (val 9))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "paine")))
    )
(defrule porneste_prajitor_paine
 	?id<-(actiune (ora "ora") (descriere "paine"))
    (test (eq ?*bucatarie* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste prajitorul de paine")))
    (printout t "foloseste prajitorul de paine la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    )
(defrule alegesandwich
    ?id<-(actiuni (val 10))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "sandwich")))
    )
(defrule porneste_sandwichmaker
 	?id<-(actiune (ora "ora") (descriere "sandwich"))
    (test (eq ?*bucatarie* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste sandwich-makerul")))
    (printout t "foloseste sandwich-makerul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 15)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    )
(defrule alegemixer
    ?id<-(actiuni (val 11))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "mixer")))
    )
(defrule porneste_mixer_blender
    ?id<-(actiune (ora "ora") (descriere "mixer"))
    (test (eq ?*bucatarie* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste mixerul/blenderul")))
    (printout t "foloseste mixerul/blenderul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 10)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    )
(defrule alegedvdp
    ?id<-(actiuni (val 12))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste dvd")))
    )
(defrule porneste_dvdplayer
	?id<-(actiune (ora "ora") (descriere "porneste dvd"))
    (test (eq ?*camera* true))
    (test (eq ?*dvdplayer* false))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste dvd-playerul")))
    (printout t "porneste dvd-playerul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*dvdplayer* true)
    (bind ?*succes* true)
    )
(defrule alegedvdo
    ?id<-(actiuni (val 13))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste dvd")))
    )
(defrule opreste_dvdplayer
    ?id<-(actiune (ora "ora") (descriere "opreste dvd"))
    (test (eq ?*camera* true))
    (test (eq ?*dvdplayer* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste dvd-playerul")))
    (printout t "opreste dvd-playerul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*dvdplayer* true)
    (bind ?*succes* true)
 	)
(defrule alegetvp
    ?id<-(actiuni (val 14))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste tv")))
    )
(defrule porneste_televizor
    ?id<-(actiune (ora "ora") (descriere "porneste tv"))
    (test (eq ?*camera* true))
    (test (eq ?*televizor* false))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste televizorul")))
    (printout t "porneste televizorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*televizor* true)
    (bind ?*succes* true)
     )
(defrule alegetvo
    ?id<-(actiuni (val 15))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste tv")))
    )
(defrule opreste_televizor
	?id<-(actiune (ora "ora") (descriere "opreste tv"))
    (test (eq ?*camera* true))
    (test (eq ?*televizor* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste televizorul")))
    (printout t "opreste televizorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*televizor* true)
    (bind ?*succes* true)
    )
(defrule alegecalculatorp
    ?id<-(actiuni (val 16))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste calculator")))
    )
(defrule porneste_calculator
    ?id<-(actiune (ora "ora") (descriere "porneste calculator"))
    (test (eq ?*camera* true))
    (test (eq ?*calculator* false))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste calculatorul")))
    (printout t "porneste calculatorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*calculator* true)
    (bind ?*succes* true)
    )
(defrule alegecalculatoro
    ?id<-(actiuni (val 17))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste calculator")))
    )
(defrule opreste_calculator
	?id<-(actiune (ora "ora") (descriere "opreste calculator"))
    (test (eq ?*camera* true))
    (test (eq ?*calculator* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste calculatorul")))
    (printout t "opreste calculatorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*dvdplayer* true)
    (bind ?*succes* true)
    )
(defrule alegeaerp
    ?id<-(actiuni (val 18))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste aer conditionat")))
    )
(defrule porneste_aer_conditionat
    ?id<-(actiune (ora "ora") (descriere "porneste aer conditionat"))
    (test (eq ?*camera* true))
    (test (eq ?*dvdplayer* false))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste aer conditionat")))
    (printout t "porneste aer conditionat la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
	(bind ?*aer_conditionat* true) 
    (bind ?*succes* true))
(defrule alegeaero
    ?id<-(actiuni (val 19))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste aer conditionat")))
    )
(defrule opreste_aer_conditionat
	?id<-(actiune (ora "ora") (descriere "opreste aer conditionat"))
    (test (eq ?*camera* true))
    (test (eq ?*aer_conditionat* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste aer conditionat")))
    (printout t "opreste aer conditionat la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*aer_conditionat* true)
    (bind ?*succes* true))
(defrule alegeaspirator
    ?id<-(actiuni (val 20))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "aspirator")))
    )
(defrule utilizeaza_aspirator
    ?id<-(actiune (ora "ora") (descriere "aspirator"))
    (test (eq ?*camera* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste aspiratorul")))
    (printout t "foloseste aspiratorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 30)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true))
(defrule alegetv
    ?id<-(actiuni (val 21))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "uita tv")))
    )
(defrule uita_tv
    ?id<-(actiune (ora "ora") (descriere "uita tv"))
    (test (eq ?*televizor* true))
    (test (eq ?*camera* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se uita la televizor")))
    (printout t "se uita la televizor"?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 50)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    )
(defrule alegecalculator
    ?id<-(actiuni (val 22))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "sta la calculator")))
    )
(defrule utilizeaza_calculator
    ?id<-(actiune (ora "ora") (descriere "sta la calculator"))
    (test (eq ?*calculator* true))
    (test (eq ?*camera* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste calculatorul")))
    (printout t "foloseste calculatorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 50)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true))
(defrule alegesta
    ?id<-(actiuni (val 23))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "sta")))
    )
(defrule sta
    ?id<-(actiune (ora "ora") (descriere "sta"))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "sta")))
    (printout t "sta la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 10)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true))
(defrule alegemananca
    ?id<-(actiuni (val 24))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "mananca")))
    )
(defrule mananca
    ?id<-(actiune (ora "ora") (descriere "mananca"))
    (test (eq ?*bucatarie* true))
    (test (neq ?*nmancare* 6))
    =>
    (retract ?id)   
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la chiuveta")))
    (printout t "se spala la chiuveta la ora "?*ora* ":"?*min* crlf)
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "mananca")))
    (printout t "mananca la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 20)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*succes* true)
    (bind ?*nmancare* (+ 1 ?*nmancare*)))

(run)